const express = require('express');
const { query, transaction, pool } = require('../config/database');
const { authenticateToken } = require('../middleware/auth');
const axios = require('axios');
const fs = require('fs').promises;
const path = require('path');
const mammoth = require('mammoth'); // Word文档解析
const pdf = require('pdf-parse');   // PDF文档解析
const XLSX = require('xlsx');       // Excel文档解析

const router = express.Router();

// 支持读取的文本文件类型
const TEXT_FILE_TYPES = [
  'txt', 'md', 'doc', 'docx', 'pdf', 'rtf',
  'js', 'ts', 'jsx', 'tsx', 'vue', 'html', 'css', 'scss', 'less',
  'py', 'java', 'cpp', 'c', 'cs', 'php', 'rb', 'go', 'rs', 'swift',
  'json', 'xml', 'yaml', 'yml', 'toml', 'ini', 'cfg', 'conf',
  'sql', 'sh', 'bat', 'ps1', 'dockerfile',
  'log', 'csv', 'tsv', 'xlsx', 'xls', 'pptx', 'ppt'
];

// 文件类型分类
const FILE_CATEGORIES = {
  'code': ['js', 'ts', 'jsx', 'tsx', 'vue', 'html', 'css', 'scss', 'less', 'py', 'java', 'cpp', 'c', 'cs', 'php', 'rb', 'go', 'rs', 'swift'],
  'document': ['txt', 'md', 'doc', 'docx', 'pdf', 'rtf', 'pptx', 'ppt'],
  'data': ['json', 'xml', 'yaml', 'yml', 'toml', 'ini', 'cfg', 'conf', 'csv', 'tsv', 'xlsx', 'xls'],
  'config': ['sql', 'sh', 'bat', 'ps1', 'dockerfile', 'log']
};

// 读取文件内容
async function readFileContent(filePath, fileType) {
  try {
    // 检查文件是否存在
    await fs.access(filePath);
    
    // 从文件名中提取文件扩展名
    const fileName = path.basename(filePath);
    const fileExtension = fileName.split('.').pop()?.toLowerCase() || '';
    
    console.log(`处理文件: ${fileName}, 数据库类型: ${fileType}, 扩展名: ${fileExtension}`);
    
    // 对于不同文件类型使用不同的读取策略
    if (fileExtension === 'docx') {
      // 读取Word文档
      try {
        const result = await mammoth.extractRawText({ path: filePath });
        const content = result.value.substring(0, 8000); // 限制内容长度
        return { 
          content: content,
          filePath: filePath,
          canRead: true,
          message: `成功读取Word文档 ${fileName} 的内容`
        };
      } catch (error) {
        console.error('读取Word文档失败:', error);
        return { 
          content: null, 
          filePath: filePath,
          canRead: false,
          message: `读取Word文档 ${fileName} 失败: ${error.message}`
        };
      }
    } else if (fileExtension === 'pdf') {
      // 读取PDF文档
      try {
        const dataBuffer = await fs.readFile(filePath);
        const data = await pdf(dataBuffer);
        const content = data.text.substring(0, 8000); // 限制内容长度
        return { 
          content: content,
          filePath: filePath,
          canRead: true,
          message: `成功读取PDF文档 ${fileName} 的内容`
        };
      } catch (error) {
        console.error('读取PDF文档失败:', error);
        return { 
          content: null, 
          filePath: filePath,
          canRead: false,
          message: `读取PDF文档 ${fileName} 失败: ${error.message}`
        };
      }
    } else if (fileExtension === 'doc') {
      // 对于老版本Word文档，暂时无法直接读取
      return { 
        content: null, 
        filePath: filePath,
        canRead: false,
        message: `文件 ${fileName} 是 DOC 格式，暂不支持内容读取（建议转换为DOCX格式）`
      };
    } else if (fileExtension === 'xlsx' || fileExtension === 'xls') {
      // 读取Excel文档
      try {
        const workbook = XLSX.readFile(filePath);
        let content = '';
        
        // 读取所有工作表
        workbook.SheetNames.forEach(sheetName => {
          const worksheet = workbook.Sheets[sheetName];
          const jsonData = XLSX.utils.sheet_to_json(worksheet, { header: 1 });
          
          content += `工作表: ${sheetName}\n`;
          jsonData.forEach((row, index) => {
            if (row && row.length > 0) {
              content += `行${index + 1}: ${row.join('\t')}\n`;
            }
          });
          content += '\n';
        });
        
        return { 
          content: content.substring(0, 8000), // 限制内容长度
          filePath: filePath,
          canRead: true,
          message: `成功读取Excel文档 ${fileName} 的内容`
        };
      } catch (error) {
        console.error('读取Excel文档失败:', error);
        return { 
          content: null, 
          filePath: filePath,
          canRead: false,
          message: `读取Excel文档 ${fileName} 失败: ${error.message}`
        };
      }
    } else if (TEXT_FILE_TYPES.includes(fileExtension)) {
      // 对于纯文本文件，直接读取内容
      const content = await fs.readFile(filePath, 'utf8');
      return { 
        content: content.substring(0, 8000), // 限制内容长度，避免token过多
        filePath: filePath,
        canRead: true,
        message: `成功读取文件 ${fileName} 的内容`
      };
    } else {
      // 其他文件类型
      return { 
        content: null, 
        filePath: filePath,
        canRead: false,
        message: `文件 ${fileName} 是 ${fileExtension.toUpperCase()} 格式，暂不支持内容读取`
      };
    }
  } catch (error) {
    console.error('读取文件内容失败:', error);
    return { 
      content: null, 
      filePath: filePath,
      canRead: false,
      message: `读取文件 ${path.basename(filePath)} 失败: ${error.message}`
    };
  }
}

// 分析文件内容并提取关键信息
function analyzeFileContent(fileName, content, fileType) {
  if (!content) return null;
  
  const fileExtension = fileName.split('.').pop()?.toLowerCase() || '';
  const analysis = {
    category: getFileCategory(fileExtension),
    keywords: [],
    summary: '',
    language: detectLanguage(content),
    size: content.length
  };
  
  // 提取关键词
  analysis.keywords = extractKeywords(content, fileExtension);
  
  // 生成摘要
  analysis.summary = generateSummary(content, fileExtension);
  
  return analysis;
}

// 获取文件分类
function getFileCategory(fileExtension) {
  for (const [category, extensions] of Object.entries(FILE_CATEGORIES)) {
    if (extensions.includes(fileExtension)) {
      return category;
    }
  }
  return 'other';
}

// 检测编程语言
function detectLanguage(content) {
  const languagePatterns = {
    'javascript': [/\b(function|const|let|var|=>|import|export)\b/g, /\b(console\.log|document\.|window\.)\b/g],
    'python': [/\b(def|class|import|from|if __name__|print\(\))\b/g, /\b(try:|except:|finally:)\b/g],
    'java': [/\b(public|private|class|interface|extends|implements)\b/g, /\b(System\.out\.println|new )\b/g],
    'html': [/\b(<html|<head|<body|<div|<span)\b/g, /\b(<!DOCTYPE|&lt;|&gt;)\b/g],
    'css': [/\b(\.|#|@media|@import|margin|padding|color|background)\b/g],
    'sql': [/\b(SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|JOIN)\b/g],
    'json': [/\b(\{|\[|"|:)\b/g],
    'markdown': [/\b(#|##|###|\*\*|\*|```)\b/g]
  };
  
  for (const [lang, patterns] of Object.entries(languagePatterns)) {
    const matches = patterns.reduce((count, pattern) => count + (content.match(pattern) || []).length, 0);
    if (matches > 3) return lang;
  }
  
  return 'text';
}

// 提取关键词
function extractKeywords(content, fileExtension) {
  const keywords = [];
  
  // 根据文件类型提取特定关键词
  if (FILE_CATEGORIES.code.includes(fileExtension)) {
    const codeKeywords = content.match(/\b(function|class|import|export|const|let|var|if|else|for|while|return|async|await)\b/g);
    if (codeKeywords) keywords.push(...new Set(codeKeywords));
  }
  
  if (FILE_CATEGORIES.document.includes(fileExtension)) {
    const docKeywords = content.match(/\b(学习|教程|指南|文档|说明|介绍|总结|分析|研究|开发|设计|实现)\b/g);
    if (docKeywords) keywords.push(...new Set(docKeywords));
  }
  
  // 提取常见技术词汇
  const techKeywords = content.match(/\b(React|Vue|Angular|Node\.js|Python|JavaScript|TypeScript|HTML|CSS|SQL|API|JSON|XML|Git|Docker|Kubernetes|AWS|Azure|Linux|Windows|MacOS)\b/g);
  if (techKeywords) keywords.push(...new Set(techKeywords));
  
  return keywords.slice(0, 10); // 限制关键词数量
}

// 生成文件摘要
function generateSummary(content, fileExtension) {
  if (content.length < 100) return content;
  
  // 对于代码文件，提取函数和类定义
  if (FILE_CATEGORIES.code.includes(fileExtension)) {
    const functions = content.match(/(function|def|class|const|let|var)\s+\w+/g);
    if (functions) {
      return `包含 ${functions.length} 个函数/类定义: ${functions.slice(0, 3).join(', ')}`;
    }
  }
  
  // 对于文档文件，提取前几句话
  if (FILE_CATEGORIES.document.includes(fileExtension)) {
    const sentences = content.split(/[。！？\n]/).filter(s => s.trim().length > 10);
    if (sentences.length > 0) {
      return sentences.slice(0, 2).join('。') + '...';
    }
  }
  
  // 默认摘要
  return content.substring(0, 200) + '...';
}

// 获取用户云盘文件内容（增强版）
async function getUserCloudFileContents(userId, limit = 10) {
  try {
    console.log(`开始获取用户 ${userId} 的云盘文件内容，限制 ${limit} 个文件`);
    
    // 获取用户最近上传的文件
    const files = await query(
      `SELECT id as file_id, file_name, file_type, file_path, created_at, file_size
       FROM cloud_files 
       WHERE user_id = ? AND file_type = 'file'
       ORDER BY created_at DESC 
       LIMIT ?`,
      [userId, limit]
    );
    
    console.log(`查询到 ${files.length} 个文件`);
    
    const fileContents = [];
    
    for (const file of files) {
      console.log(`处理文件: ${file.file_name}`);
      const fileContent = await readFileContent(file.file_path, file.file_type);
      
      // 分析文件内容
      const analysis = analyzeFileContent(file.file_name, fileContent.content, file.file_type);
      
      fileContents.push({
        fileId: file.file_id,
        fileName: file.file_name,
        fileType: file.file_type,
        fileSize: file.file_size,
        createdAt: file.created_at,
        analysis: analysis,
        ...fileContent
      });
    }
    
    console.log(`成功处理 ${fileContents.length} 个文件`);
    return fileContents;
  } catch (error) {
    console.error('获取用户云盘文件内容失败:', error);
    return [];
  }
}

// 获取用户的AI对话列表
router.get('/conversations', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    
    const conversations = await query(
      `SELECT id, title, created_at, updated_at 
       FROM ai_conversations 
       WHERE user_id = ? 
       ORDER BY updated_at DESC`,
      [userId]
    );
    
    res.json({
      success: true,
      data: conversations
    });
  } catch (error) {
    console.error('获取AI对话列表失败:', error);
    res.status(500).json({
      success: false,
      message: '获取AI对话列表失败'
    });
  }
});

// 获取特定对话的消息
router.get('/conversations/:id/messages', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const userId = req.user.id;
    
    // 验证对话属于当前用户
    const conversation = await query(
      'SELECT id FROM ai_conversations WHERE id = ? AND user_id = ?',
      [id, userId]
    );
    
    if (!conversation || conversation.length === 0) {
      return res.status(404).json({
        success: false,
        message: '对话不存在'
      });
    }
    
    const messages = await query(
      `SELECT id, role, content, created_at 
       FROM ai_messages 
       WHERE conversation_id = ? 
       ORDER BY created_at ASC`,
      [id]
    );
    
    res.json({
      success: true,
      data: messages
    });
  } catch (error) {
    console.error('获取对话消息失败:', error);
    res.status(500).json({
      success: false,
      message: '获取对话消息失败'
    });
  }
});

// 创建新的AI对话
router.post('/conversations', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const { title = '新对话' } = req.body;
    
    const result = await query(
      'INSERT INTO ai_conversations (user_id, title) VALUES (?, ?)',
      [userId, title]
    );
    
    const conversationId = result.insertId;
    
    // 创建AI的欢迎消息
    const welcomeMessage = await generateWelcomeMessage(userId);
    
    await query(
      'INSERT INTO ai_messages (conversation_id, role, content) VALUES (?, ?, ?)',
      [conversationId, 'assistant', welcomeMessage]
    );
    
    res.json({
      success: true,
      data: {
        id: conversationId,
        title,
        message: '对话创建成功'
      }
    });
  } catch (error) {
    console.error('创建AI对话失败:', error);
    console.error('错误堆栈:', error.stack);
    res.status(500).json({
      success: false,
      message: '创建AI对话失败',
      error: error.message
    });
  }
});

// 发送消息到AI
router.post('/conversations/:id/messages', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const { content } = req.body;
    const userId = req.user.id;
    
    // 验证对话属于当前用户
    const conversation = await query(
      'SELECT id FROM ai_conversations WHERE id = ? AND user_id = ?',
      [id, userId]
    );
    
    if (!conversation || conversation.length === 0) {
      return res.status(404).json({
        success: false,
        message: '对话不存在'
      });
    }
    
    // 保存用户消息
    await query(
      'INSERT INTO ai_messages (conversation_id, role, content) VALUES (?, ?, ?)',
      [id, 'user', content]
    );
    
    // 更新对话时间
    await query(
      'UPDATE ai_conversations SET updated_at = NOW() WHERE id = ?',
      [id]
    );
    
    // 生成AI回复
    const aiResponse = await generateAIResponse(userId, id, content);
    
    // 保存AI回复
    await query(
      'INSERT INTO ai_messages (conversation_id, role, content) VALUES (?, ?, ?)',
      [id, 'assistant', aiResponse]
    );
    
    res.json({
      success: true,
      data: {
        message: '消息发送成功',
        aiResponse
      }
    });
  } catch (error) {
    console.error('发送AI消息失败:', error);
    res.status(500).json({
      success: false,
      message: '发送AI消息失败'
    });
  }
});

// 删除对话
// 更新AI对话标题
router.put('/conversations/:id', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const { title } = req.body;
    const userId = req.user.id;
    
    if (!title || title.trim() === '') {
      return res.status(400).json({
        success: false,
        message: '标题不能为空'
      });
    }
    
    // 检查对话是否存在且属于当前用户
    const conversation = await query(
      'SELECT id FROM ai_conversations WHERE id = ? AND user_id = ?',
      [id, userId]
    );
    
    if (!conversation || conversation.length === 0) {
      return res.status(404).json({
        success: false,
        message: '对话不存在'
      });
    }
    
    // 更新对话标题
    await query(
      'UPDATE ai_conversations SET title = ?, updated_at = NOW() WHERE id = ?',
      [title.trim(), id]
    );
    
    res.json({
      success: true,
      message: '对话标题已更新'
    });
  } catch (error) {
    console.error('更新AI对话标题失败:', error);
    res.status(500).json({
      success: false,
      message: '更新AI对话标题失败'
    });
  }
});

router.delete('/conversations/:id', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const userId = req.user.id;
    
    // 验证对话属于当前用户
    const conversation = await query(
      'SELECT id FROM ai_conversations WHERE id = ? AND user_id = ?',
      [id, userId]
    );
    
    if (!conversation || conversation.length === 0) {
      return res.status(404).json({
        success: false,
        message: '对话不存在'
      });
    }
    
    // 删除对话及其消息
    await query('DELETE FROM ai_messages WHERE conversation_id = ?', [id]);
    await query('DELETE FROM ai_conversations WHERE id = ?', [id]);
    
    res.json({
      success: true,
      message: '对话删除成功'
    });
  } catch (error) {
    console.error('删除AI对话失败:', error);
    res.status(500).json({
      success: false,
      message: '删除AI对话失败'
    });
  }
});

// 导出对话记录
router.get('/conversations/:id/export', authenticateToken, async (req, res) => {
  try {
    const { id } = req.params;
    const userId = req.user.id;
    
    // 验证对话属于当前用户
    const conversation = await query(
      'SELECT id, title, created_at FROM ai_conversations WHERE id = ? AND user_id = ?',
      [id, userId]
    );
    
    if (!conversation || conversation.length === 0) {
      return res.status(404).json({
        success: false,
        message: '对话不存在'
      });
    }
    
    // 获取对话消息
    const messages = await query(
      `SELECT role, content, created_at 
       FROM ai_messages 
       WHERE conversation_id = ? 
       ORDER BY created_at ASC`,
      [id]
    );
    
    // 生成导出内容
    const exportContent = generateExportContent(conversation, messages);
    
    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
    res.setHeader('Content-Disposition', `attachment; filename="ai_chat_${id}.txt"`);
    res.send(exportContent);
  } catch (error) {
    console.error('导出AI对话失败:', error);
    res.status(500).json({
      success: false,
      message: '导出AI对话失败'
    });
  }
});

// 生成对话标题
router.post('/generate-title', authenticateToken, async (req, res) => {
  try {
    const { prompt } = req.body;
    
    if (!prompt) {
      return res.status(400).json({
        success: false,
        message: '提示内容不能为空'
      });
    }
    
    console.log('开始生成标题，提示词:', prompt);
    
    try {
      // 使用阿里云大模型生成标题
      const title = await generateTitleWithAI(prompt);
      
      console.log('AI生成的标题:', title);
      
      res.json({
        success: true,
        data: {
          title: title
        }
      });
    } catch (aiError) {
      console.error('AI生成标题失败:', aiError.message);
      
      // 如果AI服务失败，使用简单的关键词提取作为备选
      const simpleTitle = extractSimpleTitle(prompt);
      res.json({
        success: true,
        data: {
          title: simpleTitle
        }
      });
    }
  } catch (error) {
    console.error('生成对话标题失败:', error);
    res.status(500).json({
      success: false,
      message: '生成对话标题失败'
    });
  }
});

// 使用AI生成标题或学习计划
async function generateTitleWithAI(prompt) {
  try {
    // 设置API密钥
    const apiKey = process.env.ALIYUN_API_KEY;
    const model = process.env.ALIYUN_MODEL || 'qwen-flash';
    
    if (!apiKey) {
      console.error('阿里云API密钥未配置');
      throw new Error('AI服务未配置');
    }
    
    // 判断是否是学习计划生成请求
    const isStudyPlanRequest = prompt.includes('学习计划') || prompt.includes('JSON格式') || prompt.includes('todos');
    
    let messages;
    let maxTokens;
    let temperature;
    
    if (isStudyPlanRequest) {
      // 学习计划生成
      messages = [
        {
          role: 'system',
          content: '你是一个专业的学习规划师。请根据用户的学习需求，生成一个完整的学习计划JSON。要求：1. 必须返回完整的JSON格式；2. 包含title、description、startDate、endDate、todos字段；3. 不要添加任何其他文字或解释；4. JSON必须是有效的格式。'
        },
        {
          role: 'user',
          content: prompt
        }
      ];
      maxTokens = 1000;
      temperature = 0.7;
    } else {
      // 简单标题生成
      messages = [
        {
          role: 'system',
          content: '你是一个专业的标题生成助手。请根据对话内容生成一个简洁、准确的标题，要求：1. 标题长度不超过10个字符；2. 准确概括对话主题；3. 使用中文；4. 只返回标题，不要其他内容。'
        },
        {
          role: 'user',
          content: prompt
        }
      ];
      maxTokens = 50;
      temperature = 0.3;
    }

    // 调用阿里云大模型API
    const response = await axios.post('https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation', {
      model: model,
      input: {
        messages: messages
      },
      parameters: {
        max_tokens: maxTokens,
        temperature: temperature
      }
    }, {
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      },
      timeout: 15000
    });

    if (response.data && response.data.output && response.data.output.text) {
      let result = response.data.output.text.trim();
      
      if (isStudyPlanRequest) {
        // 对于学习计划，直接返回完整内容
        return result;
      } else {
        // 对于标题，进行清理
        result = result.replace(/['"]/g, '').trim();
        
        // 确保不超过10个字符
        if (result.length > 10) {
          result = result.substring(0, 10);
        }
        
        return result;
      }
    } else {
      throw new Error('AI响应格式错误');
    }
  } catch (error) {
    console.error('AI生成失败:', error);
    throw error;
  }
}

// 简单的标题提取函数
function extractSimpleTitle(prompt) {
  // 从提示词中提取用户问题部分
  const userQuestionMatch = prompt.match(/用户问题：(.+?)(?=AI回答|$)/s);
  if (userQuestionMatch) {
    const userQuestion = userQuestionMatch[1].trim();
    
    // 简单的关键词匹配
    if (userQuestion.includes('python') || userQuestion.includes('Python')) {
      return 'Python编程';
    } else if (userQuestion.includes('javascript') || userQuestion.includes('JavaScript')) {
      return 'JavaScript开发';
    } else if (userQuestion.includes('java')) {
      return 'Java编程';
    } else if (userQuestion.includes('react')) {
      return 'React开发';
    } else if (userQuestion.includes('vue')) {
      return 'Vue开发';
    } else if (userQuestion.includes('算法')) {
      return '算法学习';
    } else if (userQuestion.includes('数据库')) {
      return '数据库学习';
    } else if (userQuestion.includes('AI') || userQuestion.includes('人工智能')) {
      return 'AI学习';
    } else if (userQuestion.includes('前端')) {
      return '前端开发';
    } else if (userQuestion.includes('后端')) {
      return '后端开发';
    } else {
      // 返回用户问题的前10个字符
      return userQuestion.length > 10 ? userQuestion.substring(0, 10) : userQuestion;
    }
  }
  
  return '新对话';
}

// 使用AI生成智能建议问题
async function generateSmartSuggestions(recentMessages) {
  try {
    // 设置API密钥
    const apiKey = process.env.ALIYUN_API_KEY;
    const model = process.env.ALIYUN_MODEL || 'qwen-flash';
    
    if (!apiKey) {
      console.error('阿里云API密钥未配置');
      return generateDefaultSuggestions();
    }
    
    // 构建聊天内容摘要（按时间顺序，从早到晚）
    const reversedMessages = recentMessages.reverse();
    const chatSummary = reversedMessages.map(msg => 
      `${msg.role === 'user' ? '用户' : 'AI'}: ${msg.content.substring(0, 100)}...`
    ).join('\n');
    
    console.log('构建的聊天摘要:', chatSummary);
    
    // 构建消息
    const messages = [
      {
        role: 'system',
        content: '你是一个智能助手，需要根据用户的聊天历史生成3-4个相关的建议问题。要求：1. 问题要基于聊天内容，具有连贯性；2. 问题要实用且有价值；3. 问题要简洁明了；4. 每个问题不超过20个字符；5. 只返回问题列表，每行一个问题，不要其他内容。'
      },
      {
        role: 'user',
        content: `基于以下聊天内容，生成3-4个用户可能会问的相关问题：\n\n${chatSummary}`
      }
    ];

    // 调用阿里云大模型API
    const response = await axios.post('https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation', {
      model: model,
      input: {
        messages: messages
      },
      parameters: {
        max_tokens: 200,
        temperature: 0.7
      }
    }, {
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      },
      timeout: 10000
    });

    if (response.data && response.data.output && response.data.output.text) {
      const suggestions = response.data.output.text
        .split('\n')
        .map(s => s.trim())
        .filter(s => s.length > 0 && s.length <= 20)
        .slice(0, 4); // 最多4个建议
      
      return suggestions.length > 0 ? suggestions : generateDefaultSuggestions();
    } else {
      throw new Error('AI响应格式错误');
    }
  } catch (error) {
    console.error('AI生成建议问题失败:', error);
    return generateDefaultSuggestions();
  }
}

// 生成默认建议问题
function generateDefaultSuggestions() {
  return [
    '请帮我写一个Python函数',
    '解释一下什么是机器学习',
    '如何优化网站性能',
    '推荐一些学习资源'
  ];
}

// 获取智能建议问题（基于最近聊天内容）
router.get('/suggestions/:conversationId', authenticateToken, async (req, res) => {
  try {
    const { conversationId } = req.params;
    const userId = req.user.id;
    
    // 验证对话属于当前用户
    const conversation = await query(
      'SELECT id FROM ai_conversations WHERE id = ? AND user_id = ?',
      [conversationId, userId]
    );
    
    if (!conversation || conversation.length === 0) {
      return res.status(404).json({
        success: false,
        message: '对话不存在'
      });
    }
    
    // 获取最近4次聊天内容（确保获取最新的消息）
    const recentMessages = await query(
      `SELECT role, content, created_at 
       FROM ai_messages 
       WHERE conversation_id = ? 
       ORDER BY created_at DESC 
       LIMIT 4`,
      [conversationId]
    );
    
    console.log('获取到的最近消息:', recentMessages);
    
    if (recentMessages.length === 0) {
      // 如果没有聊天记录，返回默认建议
      const defaultSuggestions = [
        '请帮我写一个Python函数',
        '解释一下什么是机器学习',
        '如何优化网站性能',
        '推荐一些学习资源'
      ];
      
      return res.json({
        success: true,
        data: defaultSuggestions
      });
    }
    
    // 使用AI生成基于聊天内容的建议问题
    const suggestions = await generateSmartSuggestions(recentMessages);
    
    res.json({
      success: true,
      data: suggestions
    });
  } catch (error) {
    console.error('获取建议问题失败:', error);
    res.status(500).json({
      success: false,
      message: '获取建议问题失败'
    });
  }
});

// 获取推荐问题（默认）
router.get('/suggestions', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    
    // 获取用户基本信息
    const user = await query(
      'SELECT username, email, created_at FROM users WHERE id = ?',
      [userId]
    );
    
    // 获取云盘文件信息
    const cloudFiles = await query(
      `SELECT file_name, file_type, created_at 
       FROM cloud_files 
       WHERE user_id = ? 
       ORDER BY created_at DESC 
       LIMIT 10`,
      [userId]
    );
    
    // 生成个性化推荐问题
    const suggestions = generateSuggestions(user, cloudFiles);
    
    res.json({
      success: true,
      data: suggestions
    });
  } catch (error) {
    console.error('获取推荐问题失败:', error);
    res.status(500).json({
      success: false,
      message: '获取推荐问题失败'
    });
  }
});

// 生成AI欢迎消息
async function generateWelcomeMessage(userId) {
  try {
    // 获取用户基本信息
    const user = await query(
      'SELECT username, email FROM users WHERE id = ?',
      [userId]
    );
    
    const welcomeMessages = [
      `你好 ${user[0]?.username || '用户'}！我是你的AI学习助手，很高兴为你服务！`,
      `欢迎 ${user[0]?.username || '用户'}！我是你的专属AI助手，有什么可以帮助你的吗？`,
      `你好！我是你的AI学习伙伴，让我们开始愉快的学习之旅吧！`
    ];
    
    return welcomeMessages[Math.floor(Math.random() * welcomeMessages.length)];
  } catch (error) {
    console.error('生成欢迎消息失败:', error);
    return '你好！我是你的AI学习助手，很高兴为你服务！';
  }
}

// 生成AI回复
async function generateAIResponse(userId, conversationId, userMessage) {
  try {
    console.log('=== AI回复生成开始 ===');
    console.log('用户ID:', userId);
    console.log('对话ID:', conversationId);
    console.log('用户消息:', userMessage);
    
    // 获取用户基本信息
    const user = await query(
      'SELECT username, email, created_at FROM users WHERE id = ?',
      [userId]
    );
    console.log('用户信息:', user[0]);
    
    // 获取云盘文件内容（增强版）
    console.log('开始获取云盘文件内容...');
    const cloudFileContents = await getUserCloudFileContents(userId, 5);
    console.log('云盘文件内容数量:', cloudFileContents.length);
    cloudFileContents.forEach((file, index) => {
      console.log(`文件${index + 1}:`, {
        fileName: file.fileName,
        fileType: file.fileType,
        canRead: file.canRead,
        contentLength: file.content ? file.content.length : 0,
        message: file.message
      });
    });
    
    // 获取对话历史
    const history = await query(
      `SELECT role, content 
       FROM ai_messages 
       WHERE conversation_id = ? 
       ORDER BY created_at DESC 
       LIMIT 10`,
      [conversationId]
    );
    console.log('对话历史数量:', history.length);
    
    // 使用阿里云大模型生成回复
    const response = await generateRealAIResponse(user, cloudFileContents, userMessage, history);
    console.log('AI回复生成完成');
    console.log('=== AI回复生成结束 ===');
    return response;
  } catch (error) {
    console.error('生成AI回复失败:', error);
    return '抱歉，我现在无法回复你的消息，请稍后再试。';
  }
}

// 使用阿里云大模型生成真实回复
async function generateRealAIResponse(user, cloudFileContents, userMessage, history) {
  try {
    // 设置API密钥
    const apiKey = process.env.ALIYUN_API_KEY;
    const model = process.env.ALIYUN_MODEL || 'qwen-flash';
    
    if (!apiKey) {
      console.error('阿里云API密钥未配置');
      return generateMockAIResponse(user, cloudFileContents, userMessage);
    }
    
    // 构建系统提示词
    let systemPrompt = `你是LinkMate学习助手，一个专业的AI学习伙伴。你的任务是帮助用户提高学习效率，解答学习问题，提供学习建议。

用户信息：
- 用户名：${user[0]?.username || '用户'}
- 注册时间：${user[0]?.created_at || '未知'}`;

    // 添加云盘文件信息和内容（增强版）
    if (cloudFileContents && cloudFileContents.length > 0) {
      console.log('构建系统提示词 - 添加云盘文件信息');
      systemPrompt += `\n\n用户云盘中的文件信息：`;
      
      // 按文件类型分组
      const filesByCategory = {};
      cloudFileContents.forEach(file => {
        const category = file.analysis?.category || 'other';
        if (!filesByCategory[category]) {
          filesByCategory[category] = [];
        }
        filesByCategory[category].push(file);
      });
      
      // 按类别展示文件
      Object.entries(filesByCategory).forEach(([category, files]) => {
        const categoryNames = {
          'code': '代码文件',
          'document': '文档文件', 
          'data': '数据文件',
          'config': '配置文件',
          'other': '其他文件'
        };
        
        systemPrompt += `\n\n=== ${categoryNames[category] || category} ===`;
        
        files.forEach((file, index) => {
          console.log(`添加文件${index + 1}到系统提示词:`, file.fileName);
          systemPrompt += `\n\n文件：${file.fileName} (${file.fileType})`;
          systemPrompt += `\n上传时间：${file.createdAt}`;
          systemPrompt += `\n文件大小：${file.fileSize} 字节`;
          
          // 添加文件分析信息
          if (file.analysis) {
            systemPrompt += `\n文件分类：${file.analysis.category}`;
            systemPrompt += `\n编程语言：${file.analysis.language}`;
            if (file.analysis.keywords && file.analysis.keywords.length > 0) {
              systemPrompt += `\n关键词：${file.analysis.keywords.join(', ')}`;
            }
            if (file.analysis.summary) {
              systemPrompt += `\n内容摘要：${file.analysis.summary}`;
            }
          }
          
          if (file.canRead && file.content) {
            console.log(`文件${file.fileName}内容长度:`, file.content.length);
            systemPrompt += `\n文件内容：\n${file.content}`;
          } else {
            console.log(`文件${file.fileName}无法读取:`, file.message);
            systemPrompt += `\n状态：${file.message}`;
          }
        });
      });
      
      systemPrompt += `\n\n你可以根据用户的文件内容、文件分类、关键词和摘要来回答问题，提供更精准的学习建议。如果用户询问关于特定文件的问题，请基于文件内容进行回答。你可以根据文件类型提供相应的学习建议。`;
      console.log('系统提示词构建完成，总长度:', systemPrompt.length);
    } else {
      console.log('用户云盘中没有文件');
    }
    
    systemPrompt += `\n\n请根据用户的问题、背景信息和云盘文件内容，提供专业、有用的学习建议。回答要简洁明了，实用性强。`;

    // 构建对话历史
    let messages = [
      { role: 'system', content: systemPrompt }
    ];
    
    // 添加历史对话（按时间顺序）
    if (history && history.length > 0) {
      const reversedHistory = history.reverse(); // 反转顺序，从早到晚
      reversedHistory.forEach(msg => {
        messages.push({
          role: msg.role === 'user' ? 'user' : 'assistant',
          content: msg.content
        });
      });
    }
    
    // 添加当前用户消息
    messages.push({
      role: 'user',
      content: userMessage
    });

    // 调用阿里云大模型API
    const response = await axios.post('https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation', {
      model: model,
      input: {
        messages: messages
      },
      parameters: {
        max_tokens: 1000,
        temperature: 0.7
      }
    }, {
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json'
      }
    });

    if (response.data && response.data.output && response.data.output.text) {
      return response.data.output.text;
    } else {
      console.error('阿里云API响应格式异常:', response.data);
      return generateMockAIResponse(user, cloudFileContents, userMessage);
    }
    
  } catch (error) {
    console.error('调用阿里云大模型失败:', error);
    return generateMockAIResponse(user, cloudFileContents, userMessage);
  }
}

// 生成模拟AI回复
function generateMockAIResponse(user, cloudFileContents, userMessage) {
  // 检查是否有可读的文件内容
  const readableFiles = cloudFileContents.filter(file => file.canRead && file.content);
  
  if (readableFiles.length > 0) {
    const fileNames = readableFiles.map(file => file.fileName).join('、');
    return `我理解你的问题"${userMessage}"。我看到你的云盘中有一些相关文件（${fileNames}），这些文件的内容可能会对你的学习有帮助。基于这些文件的内容，我建议你仔细阅读相关材料，并结合实际问题进行学习。`;
  } else if (cloudFileContents.length > 0) {
    const fileNames = cloudFileContents.map(file => file.fileName).join('、');
    return `关于"${userMessage}"，我看到你的云盘中有一些文件（${fileNames}），虽然我无法直接读取这些文件的内容，但建议你可以参考这些文件来辅助学习。`;
  } else {
    const responses = [
      `我理解你的问题"${userMessage}"。基于你的学习情况，我建议你...`,
      `这是一个很好的问题！根据你的学习进度，我建议你...`,
      `我注意到你最近在学习相关内容，关于"${userMessage}"，我的建议是...`
    ];
    return responses[Math.floor(Math.random() * responses.length)];
  }
}

// 生成导出内容
function generateExportContent(conversation, messages) {
  let content = `AI对话记录\n`;
  content += `对话标题: ${conversation.title}\n`;
  content += `创建时间: ${conversation.created_at}\n`;
  content += `\n对话内容:\n`;
  content += `====================\n\n`;
  
  messages.forEach((message, index) => {
    const role = message.role === 'user' ? '用户' : 'AI助手';
    const time = new Date(message.created_at).toLocaleString('zh-CN');
    content += `[${time}] ${role}: ${message.content}\n\n`;
  });
  
  return content;
}

// 生成推荐问题
function generateSuggestions(user, cloudFiles) {
  const baseSuggestions = [
    '如何提高学习效率？',
    '推荐一些学习方法',
    '如何制定学习计划？',
    '如何保持学习动力？'
  ];
  
  const personalizedSuggestions = [];
  
  // 基于云盘文件生成个性化问题
  if (cloudFiles && cloudFiles.length > 0) {
    const fileTypes = [...new Set(cloudFiles.map(f => f.file_type))];
    if (fileTypes.includes('pdf')) {
      personalizedSuggestions.push('如何更好地阅读PDF文档？');
    }
    if (fileTypes.includes('mp4')) {
      personalizedSuggestions.push('如何高效学习视频课程？');
    }
  }
  
  return [...baseSuggestions, ...personalizedSuggestions].slice(0, 8);
}

// 获取用户云盘文件内容信息（用于AI分析）
router.get('/cloud-files/contents', authenticateToken, async (req, res) => {
  try {
    const userId = req.user.id;
    const limit = parseInt(req.query.limit) || 10;
    
    const fileContents = await getUserCloudFileContents(userId, limit);
    
    res.json({
      success: true,
      data: fileContents
    });
  } catch (error) {
    console.error('获取云盘文件内容失败:', error);
    res.status(500).json({
      success: false,
      message: '获取云盘文件内容失败'
    });
  }
});

module.exports = router;